package org.cybzacg.encryption.enums;

/**
 * 安全策略枚举
 * 定义不同的安全级别策略
 * 
 * @author encryption team
 * @version 1.0
 */
public enum SecurityStrategyEnum {
    
    /**
     * 严格安全策略
     * 最高安全级别，所有安全检查都必须通过
     */
    STRICT("严格安全", "最高安全级别，所有安全检查都必须通过", 1),
    
    /**
     * 安全策略
     * 高安全级别，推荐用于生产环境
     */
    SAFE("安全策略", "高安全级别，推荐用于生产环境", 2),
    
    /**
     * 宽松策略
     * 中等安全级别，允许一些非关键的安全警告
     */
    LENIENT("宽松策略", "中等安全级别，允许一些非关键的安全警告", 3),
    
    /**
     * 性能优先策略
     * 最低安全级别，优先考虑性能
     */
    PERFORMANCE("性能优先", "最低安全级别，优先考虑性能", 4),
    
    /**
     * 时间窗口策略
     * 基于时间窗口的访问频率限制
     */
    TIME_WINDOW("时间窗口", "基于时间窗口的访问频率限制", 5);
    
    private final String displayName;
    private final String description;
    private final int priority;
    
    SecurityStrategyEnum(String displayName, String description, int priority) {
        this.displayName = displayName;
        this.description = description;
        this.priority = priority;
    }
    
    /**
     * 获取显示名称
     * 
     * @return 显示名称
     */
    public String getDisplayName() {
        return displayName;
    }
    
    /**
     * 获取描述
     * 
     * @return 描述
     */
    public String getDescription() {
        return description;
    }
    
    /**
     * 获取优先级
     * 数值越小优先级越高
     * 
     * @return 优先级
     */
    public int getPriority() {
        return priority;
    }
    
    /**
     * 检查是否为严格模式
     * 
     * @return 是否为严格模式
     */
    public boolean isStrict() {
        return this == STRICT;
    }
    
    /**
     * 检查是否为安全模式
     * 
     * @return 是否为安全模式
     */
    public boolean isSafe() {
        return this == SAFE;
    }
    
    /**
     * 检查是否为宽松模式
     * 
     * @return 是否为宽松模式
     */
    public boolean isLenient() {
        return this == LENIENT;
    }
    
    /**
     * 检查是否为性能优先模式
     * 
     * @return 是否为性能优先模式
     */
    public boolean isPerformance() {
        return this == PERFORMANCE;
    }
    
    /**
     * 检查是否启用日志记录
     * 
     * @return 是否启用日志记录
     */
    public boolean isLoggingEnabled() {
        return this != PERFORMANCE;
    }
    
    /**
     * 检查是否启用性能监控
     * 
     * @return 是否启用性能监控
     */
    public boolean isMonitoringEnabled() {
        return this != PERFORMANCE;
    }
    
    /**
     * 检查是否启用缓存
     * 
     * @return 是否启用缓存
     */
    public boolean isCacheEnabled() {
        return this != STRICT;
    }
    
    /**
     * 获取最大重试次数
     * 
     * @return 最大重试次数
     */
    public int getMaxRetries() {
        switch (this) {
            case STRICT:
                return 5;
            case SAFE:
                return 3;
            case LENIENT:
                return 2;
            case PERFORMANCE:
                return 1;
            default:
                return 3;
        }
    }
    
    /**
     * 获取重试间隔（毫秒）
     * 
     * @return 重试间隔
     */
    public long getRetryInterval() {
        switch (this) {
            case STRICT:
                return 2000;
            case SAFE:
                return 1000;
            case LENIENT:
                return 500;
            case PERFORMANCE:
                return 100;
            default:
                return 1000;
        }
    }
    
    /**
     * 获取超时时间（毫秒）
     * 
     * @return 超时时间
     */
    public long getTimeout() {
        switch (this) {
            case STRICT:
                return 30000;
            case SAFE:
                return 15000;
            case LENIENT:
                return 10000;
            case PERFORMANCE:
                return 5000;
            default:
                return 15000;
        }
    }
    
    /**
     * 检查是否允许弱密钥
     * 
     * @return 是否允许弱密钥
     */
    public boolean allowsWeakKeys() {
        return this == PERFORMANCE;
    }
    
    /**
     * 检查是否要求密钥验证
     * 
     * @return 是否要求密钥验证
     */
    public boolean requiresKeyValidation() {
        return this == STRICT || this == SAFE;
    }
    
    /**
     * 检查是否允许使用已弃用的算法
     * 
     * @return 是否允许使用已弃用的算法
     */
    public boolean allowsDeprecatedAlgorithms() {
        return this == PERFORMANCE;
    }
    
    /**
     * 根据名称查找策略
     * 
     * @param name 策略名称
     * @return 策略，如果未找到返回null
     */
    public static SecurityStrategyEnum fromName(String name) {
        if (name == null) {
            return null;
        }
        
        try {
            return SecurityStrategyEnum.valueOf(name.toUpperCase());
        } catch (IllegalArgumentException e) {
            return null;
        }
    }
    
    /**
     * 根据显示名称查找策略
     * 
     * @param displayName 显示名称
     * @return 策略，如果未找到返回null
     */
    public static SecurityStrategyEnum fromDisplayName(String displayName) {
        if (displayName == null) {
            return null;
        }
        
        for (SecurityStrategyEnum strategy : values()) {
            if (strategy.getDisplayName().equals(displayName)) {
                return strategy;
            }
        }
        return null;
    }
    
    /**
     * 获取默认策略
     * 
     * @return 默认策略
     */
    public static SecurityStrategyEnum getDefault() {
        return SAFE;
    }
    
    /**
     * 获取所有按优先级排序的策略
     * 
     * @return 按优先级排序的策略数组
     */
    public static SecurityStrategyEnum[] getSortedByPriority() {
        return java.util.Arrays.stream(values())
                .sorted((s1, s2) -> Integer.compare(s1.getPriority(), s2.getPriority()))
                .toArray(SecurityStrategyEnum[]::new);
    }
    
    @Override
    public String toString() {
        return displayName + " (" + description + ")";
    }
}
